home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / xmllib.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  27KB  |  1,069 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''A parser for XML, using the derived class as static DTD.'''
  5. import re
  6. import string
  7. import warnings
  8. warnings.warn('The xmllib module is obsolete.  Use xml.sax instead.', DeprecationWarning)
  9. del warnings
  10. version = '0.3'
  11.  
  12. class Error(RuntimeError):
  13.     pass
  14.  
  15. _S = '[ \t\r\n]+'
  16. _opS = '[ \t\r\n]*'
  17. _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'
  18. _QStr = '(?:\'[^\']*\'|"[^"]*")'
  19. illegal = re.compile('[^\t\r\n -~\xa0-\xff]')
  20. interesting = re.compile('[]&<]')
  21. amp = re.compile('&')
  22. ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')
  23. entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')
  24. charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')
  25. space = re.compile(_S + '$')
  26. newline = re.compile('\n')
  27. attrfind = re.compile(_S + '(?P<name>' + _Name + ')(' + _opS + '=' + _opS + '(?P<value>' + _QStr + '|[-a-zA-Z0-9.:+*%?!\\(\\)_#=~]+))?')
  28. starttagopen = re.compile('<' + _Name)
  29. starttagend = re.compile(_opS + '(?P<slash>/?)>')
  30. starttagmatch = re.compile('<(?P<tagname>' + _Name + ')(?P<attrs>(?:' + attrfind.pattern + ')*)' + starttagend.pattern)
  31. endtagopen = re.compile('</')
  32. endbracket = re.compile(_opS + '>')
  33. endbracketfind = re.compile('(?:[^>\'"]|' + _QStr + ')*>')
  34. tagfind = re.compile(_Name)
  35. cdataopen = re.compile('<!\\[CDATA\\[')
  36. cdataclose = re.compile('\\]\\]>')
  37. _SystemLiteral = '(?P<%s>' + _QStr + ')'
  38. _PublicLiteral = '(?P<%s>"[-\'\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|\'[-\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*\')'
  39. _ExternalId = '(?:SYSTEM|PUBLIC' + _S + _PublicLiteral % 'pubid' + ')' + _S + _SystemLiteral % 'syslit'
  40. doctype = re.compile('<!DOCTYPE' + _S + '(?P<name>' + _Name + ')(?:' + _S + _ExternalId + ')?' + _opS)
  41. xmldecl = re.compile('<\\?xml' + _S + 'version' + _opS + '=' + _opS + '(?P<version>' + _QStr + ')' + '(?:' + _S + 'encoding' + _opS + '=' + _opS + '(?P<encoding>\'[A-Za-z][-A-Za-z0-9._]*\'|"[A-Za-z][-A-Za-z0-9._]*"))?(?:' + _S + 'standalone' + _opS + '=' + _opS + '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?' + _opS + '\\?>')
  42. procopen = re.compile('<\\?(?P<proc>' + _Name + ')' + _opS)
  43. procclose = re.compile(_opS + '\\?>')
  44. commentopen = re.compile('<!--')
  45. commentclose = re.compile('-->')
  46. doubledash = re.compile('--')
  47. attrtrans = string.maketrans(' \r\n\t', '    ')
  48. _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'
  49. ncname = re.compile(_NCName + '$')
  50. qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?(?P<local>' + _NCName + ')$')
  51. xmlns = re.compile('xmlns(?::(?P<ncname>' + _NCName + '))?$')
  52.  
  53. class XMLParser:
  54.     attributes = { }
  55.     elements = { }
  56.     __accept_unquoted_attributes = 0
  57.     __accept_missing_endtag_name = 0
  58.     __map_case = 0
  59.     __accept_utf8 = 0
  60.     __translate_attribute_references = 1
  61.     
  62.     def __init__(self, **kw):
  63.         self._XMLParser__fixed = 0
  64.         if 'accept_unquoted_attributes' in kw:
  65.             self._XMLParser__accept_unquoted_attributes = kw['accept_unquoted_attributes']
  66.         
  67.         if 'accept_missing_endtag_name' in kw:
  68.             self._XMLParser__accept_missing_endtag_name = kw['accept_missing_endtag_name']
  69.         
  70.         if 'map_case' in kw:
  71.             self._XMLParser__map_case = kw['map_case']
  72.         
  73.         if 'accept_utf8' in kw:
  74.             self._XMLParser__accept_utf8 = kw['accept_utf8']
  75.         
  76.         if 'translate_attribute_references' in kw:
  77.             self._XMLParser__translate_attribute_references = kw['translate_attribute_references']
  78.         
  79.         self.reset()
  80.  
  81.     
  82.     def __fixelements(self):
  83.         self._XMLParser__fixed = 1
  84.         self.elements = { }
  85.         self._XMLParser__fixdict(self.__dict__)
  86.         self._XMLParser__fixclass(self.__class__)
  87.  
  88.     
  89.     def __fixclass(self, kl):
  90.         self._XMLParser__fixdict(kl.__dict__)
  91.         for k in kl.__bases__:
  92.             self._XMLParser__fixclass(k)
  93.         
  94.  
  95.     
  96.     def __fixdict(self, dict):
  97.         for key in dict.keys():
  98.             if key[:6] == 'start_':
  99.                 tag = key[6:]
  100.                 (start, end) = self.elements.get(tag, (None, None))
  101.                 if start is None:
  102.                     self.elements[tag] = (getattr(self, key), end)
  103.                 
  104.             start is None
  105.             if key[:4] == 'end_':
  106.                 tag = key[4:]
  107.                 (start, end) = self.elements.get(tag, (None, None))
  108.                 if end is None:
  109.                     self.elements[tag] = (start, getattr(self, key))
  110.                 
  111.             end is None
  112.         
  113.  
  114.     
  115.     def reset(self):
  116.         self.rawdata = ''
  117.         self.stack = []
  118.         self.nomoretags = 0
  119.         self.literal = 0
  120.         self.lineno = 1
  121.         self._XMLParser__at_start = 1
  122.         self._XMLParser__seen_doctype = None
  123.         self._XMLParser__seen_starttag = 0
  124.         self._XMLParser__use_namespaces = 0
  125.         self._XMLParser__namespaces = {
  126.             'xml': None }
  127.         if self.elements is XMLParser.elements:
  128.             self._XMLParser__fixelements()
  129.         
  130.  
  131.     
  132.     def setnomoretags(self):
  133.         self.nomoretags = self.literal = 1
  134.  
  135.     
  136.     def setliteral(self, *args):
  137.         self.literal = 1
  138.  
  139.     
  140.     def feed(self, data):
  141.         self.rawdata = self.rawdata + data
  142.         self.goahead(0)
  143.  
  144.     
  145.     def close(self):
  146.         self.goahead(1)
  147.         if self._XMLParser__fixed:
  148.             self._XMLParser__fixed = 0
  149.             del self.elements
  150.         
  151.  
  152.     
  153.     def translate_references(self, data, all = 1):
  154.         if not self._XMLParser__translate_attribute_references:
  155.             return data
  156.         
  157.         i = 0
  158.         while None:
  159.             res = amp.search(data, i)
  160.             if res is None:
  161.                 return data
  162.             
  163.             s = res.start(0)
  164.             res = ref.match(data, s)
  165.             if res is None:
  166.                 self.syntax_error("bogus `&'")
  167.                 i = s + 1
  168.                 continue
  169.             
  170.             i = res.end(0)
  171.             str = res.group(1)
  172.             rescan = 0
  173.             if str[0] == '#':
  174.                 if str[1] == 'x':
  175.                     str = chr(int(str[2:], 16))
  176.                 else:
  177.                     str = chr(int(str[1:]))
  178.                 if data[i - 1] != ';':
  179.                     self.syntax_error("`;' missing after char reference")
  180.                     i = i - 1
  181.                 
  182.             elif all:
  183.                 if str in self.entitydefs:
  184.                     str = self.entitydefs[str]
  185.                     rescan = 1
  186.                 elif data[i - 1] != ';':
  187.                     self.syntax_error("bogus `&'")
  188.                     i = s + 1
  189.                     continue
  190.                 else:
  191.                     self.syntax_error("reference to unknown entity `&%s;'" % str)
  192.                     str = '&' + str + ';'
  193.             elif data[i - 1] != ';':
  194.                 self.syntax_error("bogus `&'")
  195.                 i = s + 1
  196.                 continue
  197.             
  198.             data = data[:s] + str + data[i:]
  199.             if rescan:
  200.                 i = s
  201.                 continue
  202.             i = s + len(str)
  203.  
  204.     
  205.     def getnamespace(self):
  206.         nsdict = { }
  207.         for t, d, nst in self.stack:
  208.             nsdict.update(d)
  209.         
  210.         return nsdict
  211.  
  212.     
  213.     def goahead(self, end):
  214.         rawdata = self.rawdata
  215.         i = 0
  216.         n = len(rawdata)
  217.         while i < n:
  218.             if i > 0:
  219.                 self._XMLParser__at_start = 0
  220.             
  221.             if self.nomoretags:
  222.                 data = rawdata[i:n]
  223.                 self.handle_data(data)
  224.                 self.lineno = self.lineno + data.count('\n')
  225.                 i = n
  226.                 break
  227.             
  228.             res = interesting.search(rawdata, i)
  229.             if res:
  230.                 j = res.start(0)
  231.             else:
  232.                 j = n
  233.             if i < j:
  234.                 data = rawdata[i:j]
  235.                 if self._XMLParser__at_start and space.match(data) is None:
  236.                     self.syntax_error('illegal data at start of file')
  237.                 
  238.                 self._XMLParser__at_start = 0
  239.                 if not (self.stack) and space.match(data) is None:
  240.                     self.syntax_error('data not in content')
  241.                 
  242.                 if not (self._XMLParser__accept_utf8) and illegal.search(data):
  243.                     self.syntax_error('illegal character in content')
  244.                 
  245.                 self.handle_data(data)
  246.                 self.lineno = self.lineno + data.count('\n')
  247.             
  248.             i = j
  249.             if i == n:
  250.                 break
  251.             
  252.             if rawdata[i] == '<':
  253.                 if starttagopen.match(rawdata, i):
  254.                     if self.literal:
  255.                         data = rawdata[i]
  256.                         self.handle_data(data)
  257.                         self.lineno = self.lineno + data.count('\n')
  258.                         i = i + 1
  259.                         continue
  260.                     
  261.                     k = self.parse_starttag(i)
  262.                     if k < 0:
  263.                         break
  264.                     
  265.                     self._XMLParser__seen_starttag = 1
  266.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  267.                     i = k
  268.                     continue
  269.                 
  270.                 if endtagopen.match(rawdata, i):
  271.                     k = self.parse_endtag(i)
  272.                     if k < 0:
  273.                         break
  274.                     
  275.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  276.                     i = k
  277.                     continue
  278.                 
  279.                 if commentopen.match(rawdata, i):
  280.                     if self.literal:
  281.                         data = rawdata[i]
  282.                         self.handle_data(data)
  283.                         self.lineno = self.lineno + data.count('\n')
  284.                         i = i + 1
  285.                         continue
  286.                     
  287.                     k = self.parse_comment(i)
  288.                     if k < 0:
  289.                         break
  290.                     
  291.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  292.                     i = k
  293.                     continue
  294.                 
  295.                 if cdataopen.match(rawdata, i):
  296.                     k = self.parse_cdata(i)
  297.                     if k < 0:
  298.                         break
  299.                     
  300.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  301.                     i = k
  302.                     continue
  303.                 
  304.                 res = xmldecl.match(rawdata, i)
  305.                 if res:
  306.                     if not self._XMLParser__at_start:
  307.                         self.syntax_error('<?xml?> declaration not at start of document')
  308.                     
  309.                     (version, encoding, standalone) = res.group('version', 'encoding', 'standalone')
  310.                     if version[1:-1] != '1.0':
  311.                         raise Error('only XML version 1.0 supported')
  312.                     
  313.                     if encoding:
  314.                         encoding = encoding[1:-1]
  315.                     
  316.                     if standalone:
  317.                         standalone = standalone[1:-1]
  318.                     
  319.                     self.handle_xml(encoding, standalone)
  320.                     i = res.end(0)
  321.                     continue
  322.                 
  323.                 res = procopen.match(rawdata, i)
  324.                 if res:
  325.                     k = self.parse_proc(i)
  326.                     if k < 0:
  327.                         break
  328.                     
  329.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  330.                     i = k
  331.                     continue
  332.                 
  333.                 res = doctype.match(rawdata, i)
  334.                 if res:
  335.                     if self.literal:
  336.                         data = rawdata[i]
  337.                         self.handle_data(data)
  338.                         self.lineno = self.lineno + data.count('\n')
  339.                         i = i + 1
  340.                         continue
  341.                     
  342.                     if self._XMLParser__seen_doctype:
  343.                         self.syntax_error('multiple DOCTYPE elements')
  344.                     
  345.                     if self._XMLParser__seen_starttag:
  346.                         self.syntax_error('DOCTYPE not at beginning of document')
  347.                     
  348.                     k = self.parse_doctype(res)
  349.                     if k < 0:
  350.                         break
  351.                     
  352.                     self._XMLParser__seen_doctype = res.group('name')
  353.                     if self._XMLParser__map_case:
  354.                         self._XMLParser__seen_doctype = self._XMLParser__seen_doctype.lower()
  355.                     
  356.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  357.                     i = k
  358.                     continue
  359.                 
  360.             elif rawdata[i] == '&':
  361.                 if self.literal:
  362.                     data = rawdata[i]
  363.                     self.handle_data(data)
  364.                     i = i + 1
  365.                     continue
  366.                 
  367.                 res = charref.match(rawdata, i)
  368.                 if res is not None:
  369.                     i = res.end(0)
  370.                     if rawdata[i - 1] != ';':
  371.                         self.syntax_error("`;' missing in charref")
  372.                         i = i - 1
  373.                     
  374.                     if not self.stack:
  375.                         self.syntax_error('data not in content')
  376.                     
  377.                     self.handle_charref(res.group('char')[:-1])
  378.                     self.lineno = self.lineno + res.group(0).count('\n')
  379.                     continue
  380.                 
  381.                 res = entityref.match(rawdata, i)
  382.                 if res is not None:
  383.                     i = res.end(0)
  384.                     if rawdata[i - 1] != ';':
  385.                         self.syntax_error("`;' missing in entityref")
  386.                         i = i - 1
  387.                     
  388.                     name = res.group('name')
  389.                     if self._XMLParser__map_case:
  390.                         name = name.lower()
  391.                     
  392.                     if name in self.entitydefs:
  393.                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]
  394.                         n = len(rawdata)
  395.                         i = res.start(0)
  396.                     else:
  397.                         self.unknown_entityref(name)
  398.                     self.lineno = self.lineno + res.group(0).count('\n')
  399.                     continue
  400.                 
  401.             elif rawdata[i] == ']':
  402.                 if self.literal:
  403.                     data = rawdata[i]
  404.                     self.handle_data(data)
  405.                     i = i + 1
  406.                     continue
  407.                 
  408.                 if n - i < 3:
  409.                     break
  410.                 
  411.                 if cdataclose.match(rawdata, i):
  412.                     self.syntax_error("bogus `]]>'")
  413.                 
  414.                 self.handle_data(rawdata[i])
  415.                 i = i + 1
  416.                 continue
  417.             else:
  418.                 raise Error('neither < nor & ??')
  419.             break
  420.         if i > 0:
  421.             self._XMLParser__at_start = 0
  422.         
  423.         if end and i < n:
  424.             data = rawdata[i]
  425.             self.syntax_error("bogus `%s'" % data)
  426.             if not (self._XMLParser__accept_utf8) and illegal.search(data):
  427.                 self.syntax_error('illegal character in content')
  428.             
  429.             self.handle_data(data)
  430.             self.lineno = self.lineno + data.count('\n')
  431.             self.rawdata = rawdata[i + 1:]
  432.             return self.goahead(end)
  433.         
  434.         self.rawdata = rawdata[i:]
  435.         if end:
  436.             if not self._XMLParser__seen_starttag:
  437.                 self.syntax_error('no elements in file')
  438.             
  439.             if self.stack:
  440.                 self.syntax_error('missing end tags')
  441.                 while self.stack:
  442.                     self.finish_endtag(self.stack[-1][0])
  443.             
  444.         
  445.  
  446.     
  447.     def parse_comment(self, i):
  448.         rawdata = self.rawdata
  449.         if rawdata[i:i + 4] != '<!--':
  450.             raise Error('unexpected call to handle_comment')
  451.         
  452.         res = commentclose.search(rawdata, i + 4)
  453.         if res is None:
  454.             return -1
  455.         
  456.         if doubledash.search(rawdata, i + 4, res.start(0)):
  457.             self.syntax_error("`--' inside comment")
  458.         
  459.         if rawdata[res.start(0) - 1] == '-':
  460.             self.syntax_error('comment cannot end in three dashes')
  461.         
  462.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 4, res.start(0)):
  463.             self.syntax_error('illegal character in comment')
  464.         
  465.         self.handle_comment(rawdata[i + 4:res.start(0)])
  466.         return res.end(0)
  467.  
  468.     
  469.     def parse_doctype(self, res):
  470.         rawdata = self.rawdata
  471.         n = len(rawdata)
  472.         name = res.group('name')
  473.         if self._XMLParser__map_case:
  474.             name = name.lower()
  475.         
  476.         (pubid, syslit) = res.group('pubid', 'syslit')
  477.         if pubid is not None:
  478.             pubid = pubid[1:-1]
  479.             pubid = ' '.join(pubid.split())
  480.         
  481.         if syslit is not None:
  482.             syslit = syslit[1:-1]
  483.         
  484.         j = k = res.end(0)
  485.         if k >= n:
  486.             return -1
  487.         
  488.         if rawdata[k] == '[':
  489.             level = 0
  490.             k = k + 1
  491.             dq = sq = 0
  492.             while k < n:
  493.                 c = rawdata[k]
  494.                 if not sq and c == '"':
  495.                     dq = not dq
  496.                 elif not dq and c == "'":
  497.                     sq = not sq
  498.                 elif sq or dq:
  499.                     pass
  500.                 elif level <= 0 and c == ']':
  501.                     res = endbracket.match(rawdata, k + 1)
  502.                     if res is None:
  503.                         return -1
  504.                     
  505.                     self.handle_doctype(name, pubid, syslit, rawdata[j + 1:k])
  506.                     return res.end(0)
  507.                 elif c == '<':
  508.                     level = level + 1
  509.                 elif c == '>':
  510.                     level = level - 1
  511.                     if level < 0:
  512.                         self.syntax_error("bogus `>' in DOCTYPE")
  513.                     
  514.                 
  515.                 k = k + 1
  516.         
  517.         res = endbracketfind.match(rawdata, k)
  518.         if res is None:
  519.             return -1
  520.         
  521.         if endbracket.match(rawdata, k) is None:
  522.             self.syntax_error('garbage in DOCTYPE')
  523.         
  524.         self.handle_doctype(name, pubid, syslit, None)
  525.         return res.end(0)
  526.  
  527.     
  528.     def parse_cdata(self, i):
  529.         rawdata = self.rawdata
  530.         if rawdata[i:i + 9] != '<![CDATA[':
  531.             raise Error('unexpected call to parse_cdata')
  532.         
  533.         res = cdataclose.search(rawdata, i + 9)
  534.         if res is None:
  535.             return -1
  536.         
  537.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 9, res.start(0)):
  538.             self.syntax_error('illegal character in CDATA')
  539.         
  540.         if not self.stack:
  541.             self.syntax_error('CDATA not in content')
  542.         
  543.         self.handle_cdata(rawdata[i + 9:res.start(0)])
  544.         return res.end(0)
  545.  
  546.     __xml_namespace_attributes = {
  547.         'ns': None,
  548.         'src': None,
  549.         'prefix': None }
  550.     
  551.     def parse_proc(self, i):
  552.         rawdata = self.rawdata
  553.         end = procclose.search(rawdata, i)
  554.         if end is None:
  555.             return -1
  556.         
  557.         j = end.start(0)
  558.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 2, j):
  559.             self.syntax_error('illegal character in processing instruction')
  560.         
  561.         res = tagfind.match(rawdata, i + 2)
  562.         if res is None:
  563.             raise Error('unexpected call to parse_proc')
  564.         
  565.         k = res.end(0)
  566.         name = res.group(0)
  567.         if self._XMLParser__map_case:
  568.             name = name.lower()
  569.         
  570.         if name == 'xml:namespace':
  571.             self.syntax_error('old-fashioned namespace declaration')
  572.             self._XMLParser__use_namespaces = -1
  573.             if self._XMLParser__seen_doctype or self._XMLParser__seen_starttag:
  574.                 self.syntax_error('xml:namespace declaration too late in document')
  575.             
  576.             (attrdict, namespace, k) = self.parse_attributes(name, k, j)
  577.             if namespace:
  578.                 self.syntax_error('namespace declaration inside namespace declaration')
  579.             
  580.             for attrname in attrdict.keys():
  581.                 if attrname not in self._XMLParser__xml_namespace_attributes:
  582.                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)
  583.                     continue
  584.             
  585.             if 'ns' not in attrdict or 'prefix' not in attrdict:
  586.                 self.syntax_error('xml:namespace without required attributes')
  587.             
  588.             prefix = attrdict.get('prefix')
  589.             if ncname.match(prefix) is None:
  590.                 self.syntax_error('xml:namespace illegal prefix value')
  591.                 return end.end(0)
  592.             
  593.             if prefix in self._XMLParser__namespaces:
  594.                 self.syntax_error('xml:namespace prefix not unique')
  595.             
  596.             self._XMLParser__namespaces[prefix] = attrdict['ns']
  597.         elif name.lower() == 'xml':
  598.             self.syntax_error('illegal processing instruction target name')
  599.         
  600.         self.handle_proc(name, rawdata[k:j])
  601.         return end.end(0)
  602.  
  603.     
  604.     def parse_attributes(self, tag, i, j):
  605.         rawdata = self.rawdata
  606.         attrdict = { }
  607.         namespace = { }
  608.         while i < j:
  609.             res = attrfind.match(rawdata, i)
  610.             if res is None:
  611.                 break
  612.             
  613.             (attrname, attrvalue) = res.group('name', 'value')
  614.             if self._XMLParser__map_case:
  615.                 attrname = attrname.lower()
  616.             
  617.             i = res.end(0)
  618.             if attrvalue is None:
  619.                 self.syntax_error("no value specified for attribute `%s'" % attrname)
  620.                 attrvalue = attrname
  621.             elif "'" == "'":
  622.                 pass
  623.             elif not "'" == attrvalue[-1:]:
  624.                 if '"' == '"':
  625.                     pass
  626.                 elif '"' == attrvalue[-1:]:
  627.                     attrvalue = attrvalue[1:-1]
  628.                 elif not self._XMLParser__accept_unquoted_attributes:
  629.                     self.syntax_error("attribute `%s' value not quoted" % attrname)
  630.                 
  631.             res = xmlns.match(attrname)
  632.             if res is not None:
  633.                 ncname = res.group('ncname')
  634.                 None[namespace if not attrvalue else ''] = None
  635.                 if not self._XMLParser__use_namespaces:
  636.                     self._XMLParser__use_namespaces = len(self.stack) + 1
  637.                     continue
  638.                 continue
  639.             
  640.             if '<' in attrvalue:
  641.                 self.syntax_error("`<' illegal in attribute value")
  642.             
  643.             if attrname in attrdict:
  644.                 self.syntax_error("attribute `%s' specified twice" % attrname)
  645.             
  646.             attrvalue = attrvalue.translate(attrtrans)
  647.             attrdict[attrname] = self.translate_references(attrvalue)
  648.         return (attrdict, namespace, i)
  649.  
  650.     
  651.     def parse_starttag(self, i):
  652.         rawdata = self.rawdata
  653.         end = endbracketfind.match(rawdata, i + 1)
  654.         if end is None:
  655.             return -1
  656.         
  657.         tag = starttagmatch.match(rawdata, i)
  658.         if tag is None or tag.end(0) != end.end(0):
  659.             self.syntax_error('garbage in starttag')
  660.             return end.end(0)
  661.         
  662.         nstag = tagname = tag.group('tagname')
  663.         if self._XMLParser__map_case:
  664.             nstag = tagname = nstag.lower()
  665.         
  666.         if not (self._XMLParser__seen_starttag) and self._XMLParser__seen_doctype and tagname != self._XMLParser__seen_doctype:
  667.             self.syntax_error('starttag does not match DOCTYPE')
  668.         
  669.         if self._XMLParser__seen_starttag and not (self.stack):
  670.             self.syntax_error('multiple elements on top level')
  671.         
  672.         (k, j) = tag.span('attrs')
  673.         (attrdict, nsdict, k) = self.parse_attributes(tagname, k, j)
  674.         self.stack.append((tagname, nsdict, nstag))
  675.         if self._XMLParser__use_namespaces:
  676.             res = qname.match(tagname)
  677.         else:
  678.             res = None
  679.         if res is not None:
  680.             (prefix, nstag) = res.group('prefix', 'local')
  681.             if prefix is None:
  682.                 prefix = ''
  683.             
  684.             ns = None
  685.             for t, d, nst in self.stack:
  686.                 if prefix in d:
  687.                     ns = d[prefix]
  688.                     continue
  689.             
  690.             if ns is None and prefix != '':
  691.                 ns = self._XMLParser__namespaces.get(prefix)
  692.             
  693.             if ns is not None:
  694.                 nstag = ns + ' ' + nstag
  695.             elif prefix != '':
  696.                 nstag = prefix + ':' + nstag
  697.             
  698.             self.stack[-1] = (tagname, nsdict, nstag)
  699.         
  700.         attrnamemap = { }
  701.         for key in attrdict.keys():
  702.             attrnamemap[key] = key
  703.         
  704.         if self._XMLParser__use_namespaces:
  705.             nattrdict = { }
  706.             for key, val in attrdict.items():
  707.                 okey = key
  708.                 res = qname.match(key)
  709.                 if res is not None:
  710.                     (aprefix, key) = res.group('prefix', 'local')
  711.                     if self._XMLParser__map_case:
  712.                         key = key.lower()
  713.                     
  714.                     if aprefix is not None:
  715.                         ans = None
  716.                         for t, d, nst in self.stack:
  717.                             if aprefix in d:
  718.                                 ans = d[aprefix]
  719.                                 continue
  720.                         
  721.                         if ans is None:
  722.                             ans = self._XMLParser__namespaces.get(aprefix)
  723.                         
  724.                         if ans is not None:
  725.                             key = ans + ' ' + key
  726.                         else:
  727.                             key = aprefix + ':' + key
  728.                     
  729.                 
  730.                 nattrdict[key] = val
  731.                 attrnamemap[key] = okey
  732.             
  733.             attrdict = nattrdict
  734.         
  735.         attributes = self.attributes.get(nstag)
  736.         if attributes is not None:
  737.             for key in attrdict.keys():
  738.                 if key not in attributes:
  739.                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))
  740.                     continue
  741.             
  742.             for key, val in attributes.items():
  743.                 if val is not None and key not in attrdict:
  744.                     attrdict[key] = val
  745.                     continue
  746.             
  747.         
  748.         method = self.elements.get(nstag, (None, None))[0]
  749.         self.finish_starttag(nstag, attrdict, method)
  750.         if tag.group('slash') == '/':
  751.             self.finish_endtag(tagname)
  752.         
  753.         return tag.end(0)
  754.  
  755.     
  756.     def parse_endtag(self, i):
  757.         rawdata = self.rawdata
  758.         end = endbracketfind.match(rawdata, i + 1)
  759.         if end is None:
  760.             return -1
  761.         
  762.         res = tagfind.match(rawdata, i + 2)
  763.         if res is None:
  764.             if self.literal:
  765.                 self.handle_data(rawdata[i])
  766.                 return i + 1
  767.             
  768.             if not self._XMLParser__accept_missing_endtag_name:
  769.                 self.syntax_error('no name specified in end tag')
  770.             
  771.             tag = self.stack[-1][0]
  772.             k = i + 2
  773.         else:
  774.             tag = res.group(0)
  775.             if self._XMLParser__map_case:
  776.                 tag = tag.lower()
  777.             
  778.             if self.literal:
  779.                 if not (self.stack) or tag != self.stack[-1][0]:
  780.                     self.handle_data(rawdata[i])
  781.                     return i + 1
  782.                 
  783.             
  784.             k = res.end(0)
  785.         if endbracket.match(rawdata, k) is None:
  786.             self.syntax_error('garbage in end tag')
  787.         
  788.         self.finish_endtag(tag)
  789.         return end.end(0)
  790.  
  791.     
  792.     def finish_starttag(self, tagname, attrdict, method):
  793.         if method is not None:
  794.             self.handle_starttag(tagname, method, attrdict)
  795.         else:
  796.             self.unknown_starttag(tagname, attrdict)
  797.  
  798.     
  799.     def finish_endtag(self, tag):
  800.         self.literal = 0
  801.         if not tag:
  802.             self.syntax_error('name-less end tag')
  803.             found = len(self.stack) - 1
  804.             if found < 0:
  805.                 self.unknown_endtag(tag)
  806.                 return None
  807.             
  808.         else:
  809.             found = -1
  810.             for i in range(len(self.stack)):
  811.                 if tag == self.stack[i][0]:
  812.                     found = i
  813.                     continue
  814.             
  815.             if found == -1:
  816.                 self.syntax_error('unopened end tag')
  817.                 return None
  818.             
  819.         while len(self.stack) > found:
  820.             if found < len(self.stack) - 1:
  821.                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])
  822.             
  823.             nstag = self.stack[-1][2]
  824.             method = self.elements.get(nstag, (None, None))[1]
  825.             if method is not None:
  826.                 self.handle_endtag(nstag, method)
  827.             else:
  828.                 self.unknown_endtag(nstag)
  829.             if self._XMLParser__use_namespaces == len(self.stack):
  830.                 self._XMLParser__use_namespaces = 0
  831.             
  832.             del self.stack[-1]
  833.  
  834.     
  835.     def handle_xml(self, encoding, standalone):
  836.         pass
  837.  
  838.     
  839.     def handle_doctype(self, tag, pubid, syslit, data):
  840.         pass
  841.  
  842.     
  843.     def handle_starttag(self, tag, method, attrs):
  844.         method(attrs)
  845.  
  846.     
  847.     def handle_endtag(self, tag, method):
  848.         method()
  849.  
  850.     
  851.     def handle_charref(self, name):
  852.         
  853.         try:
  854.             if name[0] == 'x':
  855.                 n = int(name[1:], 16)
  856.             else:
  857.                 n = int(name)
  858.         except ValueError:
  859.             self.unknown_charref(name)
  860.             return None
  861.  
  862.         if n <= n:
  863.             pass
  864.         elif not n <= 255:
  865.             self.unknown_charref(name)
  866.             return None
  867.         
  868.         self.handle_data(chr(n))
  869.  
  870.     entitydefs = {
  871.         'lt': '<',
  872.         'gt': '>',
  873.         'amp': '&',
  874.         'quot': '"',
  875.         'apos': ''' }
  876.     
  877.     def handle_data(self, data):
  878.         pass
  879.  
  880.     
  881.     def handle_cdata(self, data):
  882.         pass
  883.  
  884.     
  885.     def handle_comment(self, data):
  886.         pass
  887.  
  888.     
  889.     def handle_proc(self, name, data):
  890.         pass
  891.  
  892.     
  893.     def syntax_error(self, message):
  894.         raise Error('Syntax error at line %d: %s' % (self.lineno, message))
  895.  
  896.     
  897.     def unknown_starttag(self, tag, attrs):
  898.         pass
  899.  
  900.     
  901.     def unknown_endtag(self, tag):
  902.         pass
  903.  
  904.     
  905.     def unknown_charref(self, ref):
  906.         pass
  907.  
  908.     
  909.     def unknown_entityref(self, name):
  910.         self.syntax_error("reference to unknown entity `&%s;'" % name)
  911.  
  912.  
  913.  
  914. class TestXMLParser(XMLParser):
  915.     
  916.     def __init__(self, **kw):
  917.         self.testdata = ''
  918.         XMLParser.__init__(self, **kw)
  919.  
  920.     
  921.     def handle_xml(self, encoding, standalone):
  922.         self.flush()
  923.         print 'xml: encoding =', encoding, 'standalone =', standalone
  924.  
  925.     
  926.     def handle_doctype(self, tag, pubid, syslit, data):
  927.         self.flush()
  928.         print 'DOCTYPE:', tag, repr(data)
  929.  
  930.     
  931.     def handle_data(self, data):
  932.         self.testdata = self.testdata + data
  933.         if len(repr(self.testdata)) >= 70:
  934.             self.flush()
  935.         
  936.  
  937.     
  938.     def flush(self):
  939.         data = self.testdata
  940.         if data:
  941.             self.testdata = ''
  942.             print 'data:', repr(data)
  943.         
  944.  
  945.     
  946.     def handle_cdata(self, data):
  947.         self.flush()
  948.         print 'cdata:', repr(data)
  949.  
  950.     
  951.     def handle_proc(self, name, data):
  952.         self.flush()
  953.         print 'processing:', name, repr(data)
  954.  
  955.     
  956.     def handle_comment(self, data):
  957.         self.flush()
  958.         r = repr(data)
  959.         if len(r) > 68:
  960.             r = r[:32] + '...' + r[-32:]
  961.         
  962.         print 'comment:', r
  963.  
  964.     
  965.     def syntax_error(self, message):
  966.         print 'error at line %d:' % self.lineno, message
  967.  
  968.     
  969.     def unknown_starttag(self, tag, attrs):
  970.         self.flush()
  971.         if not attrs:
  972.             print 'start tag: <' + tag + '>'
  973.         else:
  974.             print 'start tag: <' + tag,
  975.             for name, value in attrs.items():
  976.                 print name + '=' + '"' + value + '"',
  977.             
  978.             print '>'
  979.  
  980.     
  981.     def unknown_endtag(self, tag):
  982.         self.flush()
  983.         print 'end tag: </' + tag + '>'
  984.  
  985.     
  986.     def unknown_entityref(self, ref):
  987.         self.flush()
  988.         print '*** unknown entity ref: &' + ref + ';'
  989.  
  990.     
  991.     def unknown_charref(self, ref):
  992.         self.flush()
  993.         print '*** unknown char ref: &#' + ref + ';'
  994.  
  995.     
  996.     def close(self):
  997.         XMLParser.close(self)
  998.         self.flush()
  999.  
  1000.  
  1001.  
  1002. def test(args = None):
  1003.     import sys as sys
  1004.     import getopt as getopt
  1005.     time = time
  1006.     import time
  1007.     if not args:
  1008.         args = sys.argv[1:]
  1009.     
  1010.     (opts, args) = getopt.getopt(args, 'st')
  1011.     klass = TestXMLParser
  1012.     do_time = 0
  1013.     for o, a in opts:
  1014.         if o == '-s':
  1015.             klass = XMLParser
  1016.             continue
  1017.         if o == '-t':
  1018.             do_time = 1
  1019.             continue
  1020.     
  1021.     if args:
  1022.         file = args[0]
  1023.     else:
  1024.         file = 'test.xml'
  1025.     if file == '-':
  1026.         f = sys.stdin
  1027.     else:
  1028.         
  1029.         try:
  1030.             f = open(file, 'r')
  1031.         except IOError:
  1032.             msg = None
  1033.             print file, ':', msg
  1034.             sys.exit(1)
  1035.  
  1036.     data = f.read()
  1037.     if f is not sys.stdin:
  1038.         f.close()
  1039.     
  1040.     x = klass()
  1041.     t0 = time()
  1042.     
  1043.     try:
  1044.         if do_time:
  1045.             x.feed(data)
  1046.             x.close()
  1047.         else:
  1048.             for c in data:
  1049.                 x.feed(c)
  1050.             
  1051.             x.close()
  1052.     except Error:
  1053.         msg = None
  1054.         t1 = time()
  1055.         print msg
  1056.         if do_time:
  1057.             print 'total time: %g' % (t1 - t0)
  1058.         
  1059.         sys.exit(1)
  1060.  
  1061.     t1 = time()
  1062.     if do_time:
  1063.         print 'total time: %g' % (t1 - t0)
  1064.     
  1065.  
  1066. if __name__ == '__main__':
  1067.     test()
  1068.  
  1069.